使用 mcp-go 搭建服务

MCP-Go 服务架构概述

MCP (Model Context Protocol) 是一个用于AI模型与外部工具集成的协议标准。mcp-go 作为 Go 语言实现，提供了构建 MCP 服务端的完整框架，支持工具调用、资源访问和提示模板等核心功能。

在实际应用中，MCP-Go 服务常用于：

• AI Agent 工具集成：为 LLM 提供外部 API 调用能力
• 数据源连接：连接数据库、文件系统、第三方服务
• 业务流程自动化：封装复杂业务逻辑供 AI 调用

MCP 服务基础架构

核心组件架构图

服务初始化流程

快速搭建 MCP-Go 服务

项目初始化

首先创建 Go 模块并安装依赖：

// go.mod
module my-mcp-service

go 1.21

require (
    github.com/mark3labs/mcp-go v0.1.0
    github.com/go-sql-driver/mysql v1.7.1
)

基础服务器搭建

核心服务器实现：

package main

import (
    "context"
    "log"
    
    "github.com/mark3labs/mcp-go/mcp"
    "github.com/mark3labs/mcp-go/server"
)

func main() {
    // 创建 MCP 服务器
    srv := server.NewStdioServer(
        server.WithName("my-business-service"),
        server.WithVersion("1.0.0"),
    )
    
    // 注册工具
    registerTools(srv)
    
    // 启动服务
    if err := srv.Serve(context.Background()); err != nil {
        log.Fatal("服务启动失败:", err)
    }
}

业务工具注册

实际业务场景中，我们通常需要封装数据库操作、API调用等功能：

func registerTools(srv *server.StdioServer) {
    // 用户查询工具
    srv.AddTool(mcp.Tool{
        Name: "query_user",
        Description: "根据用户ID查询用户信息",
        InputSchema: map[string]interface{}{
            "type": "object",
            "properties": map[string]interface{}{
                "user_id": map[string]interface{}{
                    "type": "string",
                    "description": "用户唯一标识",
                },
            },
            "required": []string{"user_id"},
        },
    }, handleUserQuery)
    
    // 订单创建工具
    srv.AddTool(mcp.Tool{
        Name: "create_order",
        Description: "创建新订单",
        InputSchema: map[string]interface{}{
            "type": "object",
            "properties": map[string]interface{}{
                "user_id": map[string]interface{}{
                    "type": "string",
                    "description": "用户ID",
                },
                "product_id": map[string]interface{}{
                    "type": "string", 
                    "description": "商品ID",
                },
                "quantity": map[string]interface{}{
                    "type": "integer",
                    "description": "购买数量",
                },
            },
            "required": []string{"user_id", "product_id", "quantity"},
        },
    }, handleOrderCreation)
}

工具处理器实现

数据库集成场景

以用户信息查询为例，展示如何集成数据库操作：

func handleUserQuery(ctx context.Context, args map[string]interface{}) (*mcp.CallToolResult, error) {
    userID, ok := args["user_id"].(string)
    if !ok {
        return mcp.NewErrorResult("user_id 参数无效"), nil
    }
    
    // 数据库查询
    user, err := getUserFromDB(userID)
    if err != nil {
        return mcp.NewErrorResult("查询用户失败: " + err.Error()), nil
    }
    
    return mcp.NewTextResult(fmt.Sprintf(
        "用户信息: 姓名=%s, 邮箱=%s, 状态=%s", 
        user.Name, user.Email, user.Status,
    )), nil
}

func getUserFromDB(userID string) (*User, error) {
    var user User
    query := "SELECT name, email, status FROM users WHERE id = ?"
    err := db.QueryRow(query, userID).Scan(&user.Name, &user.Email, &user.Status)
    return &user, err
}

复杂业务逻辑封装

对于涉及多步骤的业务流程，可以封装成单个工具：

func handleOrderCreation(ctx context.Context, args map[string]interface{}) (*mcp.CallToolResult, error) {
    // 参数提取
    userID := args["user_id"].(string)
    productID := args["product_id"].(string)
    quantity := int(args["quantity"].(float64))
    
    // 业务逻辑执行
    order, err := processOrderCreation(userID, productID, quantity)
    if err != nil {
        return mcp.NewErrorResult("订单创建失败: " + err.Error()), nil
    }
    
    return mcp.NewTextResult(fmt.Sprintf(
        "订单创建成功: 订单号=%s, 总金额=%.2f", 
        order.ID, order.TotalAmount,
    )), nil
}

func processOrderCreation(userID, productID string, quantity int) (*Order, error) {
    // 1. 验证用户和商品
    // 2. 检查库存
    // 3. 计算价格
    // 4. 创建订单记录
    // 5. 更新库存
    // 6. 发送通知
    // ... 业务逻辑实现
}

错误处理与监控

统一错误处理

错误处理实现：

func safeToolHandler(handler ToolHandler) ToolHandler {
    return func(ctx context.Context, args map[string]interface{}) (*mcp.CallToolResult, error) {
        defer func() {
            if r := recover(); r != nil {
                log.Printf("工具执行 panic: %v", r)
            }
        }()
        
        // 执行实际处理逻辑
        result, err := handler(ctx, args)
        if err != nil {
            log.Printf("工具执行错误: %v", err)
            return mcp.NewErrorResult("服务暂时不可用"), nil
        }
        
        return result, nil
    }
}

性能监控

func withMetrics(toolName string, handler ToolHandler) ToolHandler {
    return func(ctx context.Context, args map[string]interface{}) (*mcp.CallToolResult, error) {
        start := time.Now()
        defer func() {
            duration := time.Since(start)
            log.Printf("工具 %s 执行耗时: %v", toolName, duration)
        }()
        
        return handler(ctx, args)
    }
}

生产环境部署考虑

服务健康检查

func (s *McpService) HealthCheck() error {
    // 检查数据库连接
    if err := s.db.Ping(); err != nil {
        return fmt.Errorf("数据库连接失败: %w", err)
    }
    
    // 检查外部服务
    if err := s.checkExternalServices(); err != nil {
        return fmt.Errorf("外部服务不可用: %w", err)
    }
    
    return nil
}

配置管理

type Config struct {
    Database struct {
        DSN          string `env:"DB_DSN"`
        MaxOpenConns int    `env:"DB_MAX_OPEN_CONNS" envDefault:"10"`
    }
    
    Services struct {
        PaymentAPI string `env:"PAYMENT_API_URL"`
        NotifyAPI  string `env:"NOTIFY_API_URL"`
    }
}

通过 MCP-Go 框架，我们可以快速构建功能丰富的 AI 工具服务，为 LLM 应用提供强大的外部能力扩展。关键在于合理设计工具接口、做好错误处理和性能监控，确保服务在生产环境中的稳定性和可维护性。